home *** CD-ROM | disk | FTP | other *** search
/ START Magazine / START VOL 4 NO 1.st / POGOSRC.ARC / STATEMEN.C < prev    next >
Encoding:
C/C++ Source or Header  |  1985-11-20  |  11.4 KB  |  661 lines
  1. /* statemen.c - Here's where pogo statements are parsed. */
  2.  
  3. #include <stdio.h>
  4. #include "pogo.h"
  5.  
  6. /* Parse a list of statements */
  7. get_states()
  8. {
  9. while (!got_stop)
  10.     {
  11.     if (!next_token())
  12.         return;
  13.     if (cttype == TOK_RBRACE)
  14.         {
  15.         pushback_token();
  16.         return;
  17.         }
  18.     pushback_token();
  19.     get_statement();
  20.     }
  21. }
  22.  
  23. Statement *slist, *stail;
  24.  
  25. add_statement()
  26. {
  27. Statement *ns;
  28. extern int debug_statements;
  29.  
  30. if (!debug_statements)
  31.     return;
  32. if ((ns = beg_mem(sizeof(*ns))) == NULL)
  33.     return;
  34. if (line_pos == NULL)
  35.     {
  36.     ns->line_pos = line_count+1;
  37.     ns->char_pos = 0;
  38.     }
  39. else
  40.     {
  41.     ns->line_pos = line_count;
  42.     ns->char_pos = line_pos - line_buf;
  43.     }
  44. ns->next = NULL;
  45. if (stail == NULL)
  46.     {
  47.     stail = slist = ns;
  48.     }
  49. else
  50.     {
  51.     stail = stail->next = ns;
  52.     }
  53. code_big(OP_STATEMENT, ns);
  54. }
  55.  
  56. /* read a single statement - assign, if, print, loop, etc, or a block
  57.    of statements enclosed by braces. */
  58. get_statement()
  59. {
  60. Symbol *avar;
  61. int start, middle, stop;
  62. int vtype;
  63. int lstart, lstop;
  64. int for_step;
  65. char fname[MAX_SYM_LEN];
  66. Statement *st;
  67. int oin_loop;
  68. int ok;
  69.  
  70. if (got_stop)
  71.     return;
  72. if (got_stop)
  73.     return;
  74. if (need_token())
  75.     {
  76.     if (cttype == TOK_FUNCTION || cttype == TOK_TO)
  77.         {
  78.         get_function();
  79.         }
  80.     else if (cttype == TOK_CREATURE)
  81.         {
  82.         get_creature();
  83.         }
  84.     else if (cttype == TOK_SPAWN)
  85.         {
  86.         add_statement();
  87.         get_spawn();
  88.         code_num(OP_MOVES, (NUMBER)-1);    /* disregarding id of creature */
  89.         }
  90.     else if (cttype == TOK_KILL)
  91.         {
  92.         add_statement();
  93.         if (!eat_token("("))
  94.             return;
  95.         get_iexpress();
  96.         if (got_stop)
  97.             return;
  98.         if (!eat_token(")"))
  99.             return;
  100.         code_void(OP_KILL);
  101.         }
  102.     else if (cttype == TOK_CWRITE)
  103.         {
  104.         add_statement();
  105.         get_cwrite();
  106.         }
  107.     else if (cttype == TOK_EVOLVE)
  108.         {
  109.         add_statement();
  110.         get_evolve();
  111.         }
  112.     else if (cttype == TOK_INT)
  113.         {
  114.         get_int();
  115.         }
  116.     else if (cttype == TOK_STRING)
  117.         {
  118.         get_string();
  119.         }
  120.     else if (cttype == TOK_CONSTANT)
  121.         {
  122.         get_constant();
  123.         }
  124.     else if (cttype == TOK_LOOP)
  125.         {
  126.         add_statement();
  127.         if (!loop_start())
  128.             return;
  129.         lstart = rframe->op_count;
  130.         get_statement();
  131.         loop_end(lstart);
  132.         }
  133.     else if (cttype == TOK_WHILE)
  134.         {
  135.         add_statement();
  136.         if (!loop_start())
  137.             return;
  138.         lstart = rframe->op_count;
  139.         get_iexpress();
  140.         if (got_stop)
  141.             return;
  142.         if (!add_bfixup())            /* and code conditional branch */
  143.             return;
  144.         code_num(OP_CBRA, (NUMBER)-rframe->op_count-1);
  145.         get_statement();
  146.         if (got_stop)
  147.             return;
  148.         loop_end(lstart);
  149.         }
  150.     else if (cttype == TOK_FOR)
  151.         {
  152.         add_statement();
  153.         if (!need_token())
  154.             return;
  155.         if (cttype != TOK_VAR)
  156.             {
  157.             want_variable();
  158.             return;
  159.             }
  160.         avar = csym;
  161.         get_array_ix(avar);
  162.         if (got_stop)
  163.             return;
  164.         if (!need_token())
  165.             return;
  166.         if (cttype != '=')
  167.             {
  168.             expecting_got("=", ctoke);
  169.             return;
  170.             }
  171.         finish_assign(avar);
  172.         if (got_stop)    /* check for error in assignment expression */
  173.             return;
  174.         lstart = rframe->op_count;
  175.         if (!loop_start())
  176.             return;
  177.         if (!need_token())
  178.             return;
  179.         if (cttype != TOK_TO)
  180.             {
  181.             expecting_got("to", ctoke);
  182.             return;
  183.             }
  184.         /* add the conditional branch at beginning of for loop
  185.             checking loop variable against ending value */
  186.         code_arr_var(avar);
  187.         get_iexpress();            /* and end expression */
  188.         if (got_stop)
  189.             return;
  190.         /* now deal with optional step part (assumed 1 if absent) */
  191.         for_step = 1;
  192.         if (next_token())
  193.             {
  194.             if (cttype == TOK_STEP)
  195.                 {
  196.                 need_token();
  197.                 if (cttype == '-')
  198.                     {
  199.                     need_token();
  200.                     for_step = -1;
  201.                     }
  202.                 if (cttype != TOK_NUM)
  203.                     {
  204.                     expecting_got("Number", ctoke);
  205.                     return;
  206.                     }
  207.                 for_step *= cint;
  208.                 }
  209.             else
  210.                 {
  211.                 pushback_token();
  212.                 }
  213.             }
  214.         if (for_step >= 0)            /* finish (implied) conditional expr */
  215.             {
  216.             code_void(OP_LE);
  217.             }
  218.         else
  219.             {
  220.             code_void(OP_GE);
  221.             }
  222.         if (!add_bfixup())            /* and code conditional branch */
  223.             return;
  224.         code_num(OP_CBRA, (NUMBER)-rframe->op_count-1);
  225.         get_statement();        /* get the body of for */
  226.         /* now add in code at end of for loop to increment loop var. */
  227.         code_arr_var(avar);
  228.         code_num(OP_CON, for_step );
  229.         code_big(OP_ADD);
  230.         code_arr_assign(avar);
  231.         loop_end(lstart);
  232.         }
  233.     else if (cttype == TOK_BREAK)
  234.         {
  235.         add_statement();
  236.         if (!in_loop)
  237.             {
  238.             say_fatal("Break outside of loop");
  239.             return;
  240.             }
  241.         if (!add_bfixup())
  242.             return;
  243.         code_num(OP_BRA, (NUMBER)-rframe->op_count-1);
  244.         }
  245.     else if (cttype == TOK_IF)
  246.         {
  247.         add_statement();
  248.         get_iexpress();
  249.         code_num(OP_CBRA, (NUMBER)0);
  250.         start = rframe->op_count;
  251.         get_statement();
  252.         if (!next_token())
  253.             goto codeif;
  254.         if (cttype == TOK_ELSE)
  255.             {
  256.             code_num(OP_BRA, (NUMBER)0);
  257.             middle = rframe->op_count;
  258.             get_statement();
  259.             stop = rframe->op_count;
  260.             rframe->code_buf[start-1].data.i = middle - start;
  261.             rframe->code_buf[middle-1].data.i = stop - middle;
  262.             }
  263.         else
  264.             {
  265.             pushback_token();
  266. codeif:
  267.             stop = rframe->op_count;
  268.             rframe->code_buf[start-1].data.i = stop - start;
  269.             }
  270.         }
  271.     else if (cttype == TOK_GOTO)
  272.         {
  273.         add_statement();
  274.         need_token();
  275.         if (cttype == TOK_UNDEF)
  276.             {
  277.             if ((csym = new_symbol(ctoke, FLABEL, LOCAL, rframe)) == NULL)
  278.                 return;
  279.             cttype = TOK_VAR;
  280.             }
  281.         if (cttype != TOK_VAR)
  282.             {
  283.             want_label();
  284.             return;
  285.             }
  286.         vtype = csym->type;
  287.         if (vtype != LABEL && vtype != FLABEL)
  288.             {
  289.             want_label();
  290.             return;
  291.             }
  292.         code_num(OP_BRA, (NUMBER)csym->symval.i - rframe->op_count - 1);
  293.         if (vtype == FLABEL)
  294.             {
  295.             add_fref(rframe->op_count-1, csym);
  296.             }
  297.         }
  298.     else if (secret_assignment())
  299.         ;
  300.     else if (cttype == TOK_VAR)
  301.         {
  302.         add_statement();
  303.         if (csym->type == FUNC || csym->type == FFUNC || csym->type == PREDEF)
  304.             {
  305.             struct func_frame *fuf;
  306.  
  307.             fuf = csym->symval.p;
  308.             call_func(csym,0,fuf->ret_type);
  309.             }
  310.         else 
  311.             {
  312.             most_of_assignment(csym);
  313.             }
  314.         }
  315.     else if (cttype == TOK_RETURN)
  316.         {
  317.         add_statement();
  318.         if (next_token())
  319.             {
  320.             if (cttype == '(')
  321.                 {
  322.                 pushback_token();
  323.                 ok = get_expression();
  324.                 if (got_stop)
  325.                     return;
  326.                 if (ok != fret_type)
  327.                     {
  328.                     say_fatal("Returning wrong type");
  329.                     type_mismatch(fret_type,ok);
  330.                     }
  331.                 code_void(OP_END);
  332.                 return;
  333.                 }
  334.             else
  335.                 pushback_token();
  336.             }
  337.         code_big(OP_CON, 0L);    /* return 0 if not explicit */
  338.         code_void(OP_END);
  339.         }
  340.     else if (cttype == TOK_RBRACE)
  341.         {
  342.         add_statement();
  343.         pushback_token();
  344.         return;
  345.         }
  346.     else if (cttype == TOK_LBRACE)
  347.         {
  348.         add_statement();
  349.         get_states();
  350.         if (got_stop)
  351.             return;
  352.         add_statement();
  353.         if (!next_token() || cttype != TOK_RBRACE)
  354.             {
  355.             expecting_got("closing brace", ctoke);
  356.             return;
  357.             }
  358.         }
  359.     else if (cttype == TOK_UNDEF)
  360.         {
  361.         add_statement();
  362.         strcpy(fname, ctoke);
  363.         if (!precall_func(0,INT))
  364.             {
  365.             need_token();
  366.             if (cttype != ':')
  367.                 {
  368.                 undefined(fname);
  369.                 return;
  370.                 }
  371.             if ((avar = new_symbol(fname, LABEL, LOCAL, rframe)) == NULL)
  372.                 return;
  373.             avar->symval.i = rframe->op_count;
  374.             }
  375.         }
  376.     else
  377.         {
  378.         expecting_got("Statement", ctoke);
  379.         return;
  380.         }
  381.     add_frees();
  382.     }
  383. }
  384.  
  385. most_of_assignment(avar)
  386. register Symbol *avar;
  387. {
  388. get_array_ix(avar);
  389. if (got_stop)
  390.     return;
  391. need_token();
  392. if (cttype == '=')
  393.     {
  394.     finish_some_assign(avar);
  395.     }
  396. else if (cttype == ':')
  397.     {
  398.     if (avar->type != FLABEL)
  399.         redefined(avar->name);
  400.     avar->symval.i = rframe->op_count;
  401.     avar->type = LABEL;
  402.     }
  403. else
  404.     {
  405.     say_fatal("Expecting a statement");
  406.     }
  407. }
  408.  
  409. finish_array_ix(avar)
  410. Symbol *avar;
  411. {
  412. char buf[80];
  413.  
  414. if (avar->elements == 0)
  415.     {
  416.     sprintf(buf, "%s not an array", avar->name);
  417.     say_fatal(buf);
  418.     return;
  419.     }
  420. get_iexpress();
  421. code_num(OP_CHECK, (NUMBER)avar->elements);
  422. if (got_stop)
  423.     return;
  424. if (!next_token() || cttype != ']')
  425.     {
  426.     expecting_got("]", ctoke);
  427.     return;
  428.     }
  429. }
  430.  
  431. array_ix(avar)
  432. Symbol *avar;
  433. {
  434. if (cttype == '[')
  435.     {
  436.     finish_array_ix(avar);
  437.     }
  438. else
  439.     {
  440.     if (avar->elements != 0)
  441.         say_fatal("Array without an index");
  442.     else
  443.         pushback_token();
  444.     }
  445. }
  446.  
  447. get_array_ix(avar)
  448. Symbol *avar;
  449. {
  450. if (!need_token())
  451.     return;
  452. array_ix(avar);
  453. }
  454.  
  455.  
  456. finish_assign(avar)
  457. Symbol *avar;
  458. {
  459. if (avar->type != INT)
  460.     {
  461.     say_fatal("Expecting an integer assignment");
  462.     return;
  463.     }
  464. finish_some_assign(avar);
  465. }
  466.  
  467. finish_some_assign(avar)
  468. Symbol *avar;
  469. {
  470. char buf[80];
  471. int ok;
  472.  
  473. ok = get_expression();
  474. switch (ok)
  475.     {
  476.     case INT:
  477.     case STRING:
  478.         if (ok != avar->type)
  479.             {
  480.             say_fatal("Type mismatch in = statement"); 
  481.             }
  482.         else
  483.             {
  484.             code_arr_assign(avar);
  485.             }
  486.         avar->assigned = 1;
  487.         break;
  488.     case BAD:
  489.         break;
  490.     default:
  491.         sprintf(buf, "= %s ?????", avar->name);
  492.         say_fatal(buf);
  493.         break;
  494.     }
  495. }
  496.  
  497. loop_start()
  498. {
  499. register struct break_frame *bfx;
  500.  
  501. if ((bfx = (struct break_frame *)beg_zero(sizeof(*bfx))) == NULL)
  502.     return(0);
  503. bfx->next = bfix_frame;
  504. bfix_frame = bfx;
  505. in_loop++;
  506. return(1);
  507. }
  508.  
  509. loop_end(lstart)
  510. int lstart;
  511. {
  512. register struct break_frame *bfx;
  513.  
  514. code_num(OP_BRA, (NUMBER)lstart - rframe->op_count - 1);
  515. --in_loop;
  516. bfx = bfix_frame;
  517. bfixup(rframe->op_count);
  518. bfix_frame = bfx->next;
  519. free_list(bfx->fixes);
  520. freemem(bfx);
  521. }
  522.  
  523.  
  524. need_constant()
  525. {
  526. struct pogo_op *op;
  527.  
  528. get_iexpress();    /* code up an expression */
  529. if (got_stop)
  530.     return(0);
  531. op = rframe->code_buf + rframe->op_count - 1;    
  532. if (op->type != OP_CON)    /* make sure it was a constant expression */
  533.     {
  534.     say_fatal("Expecting a numerical constant");
  535.     return(0);
  536.     }
  537. rframe->op_count -= 1;
  538. return(op->data.i);
  539. }
  540.  
  541. get_constant()
  542. {
  543. Symbol *ns;
  544.  
  545. for (;;)
  546.     {
  547.     if (!need_token())
  548.         break;
  549.     if (cttype != TOK_UNDEF)
  550.         {
  551.         redefined(ctoke);
  552.         return;
  553.         }
  554.     if ((ns = new_symbol(ctoke, CONSTANT, 
  555.         (rframe == global_frame ? GLOBAL : LOCAL), rframe)) == NULL)
  556.         return;
  557.     if (!eat_token("="))
  558.         {
  559.         expecting_got("=", ctoke);
  560.         return;
  561.         }
  562.     ns->symval.i = need_constant();
  563.     if (got_stop)
  564.         return;
  565.     if (!next_token())
  566.         return;
  567.     if (cttype != ',')
  568.         {
  569.         pushback_token();
  570.         break;
  571.         }
  572.     }
  573. }
  574.  
  575. /* declare a string valued variable */
  576. get_string()
  577. {
  578. get_new_var(STRING);
  579. }
  580.  
  581. /* declare an integer valued variable */
  582. get_int()
  583. {
  584. get_new_var(INT);
  585. }
  586.  
  587. get_new_var(type)
  588. int type;
  589. {
  590. int count = 0;
  591. struct pogo_op *op;
  592. Symbol *ns;
  593. int elements;
  594.  
  595. for (;;)
  596.     {
  597.     if (!next_token())
  598.         {
  599.         if (count == 0)
  600.             want_variable();
  601.         return;
  602.         }
  603.     if (cttype == TOK_VAR)
  604.         {
  605.         redefined(ctoke);
  606.         return;
  607.         }
  608.     if (cttype != TOK_UNDEF)
  609.         {
  610.         if (count == 0)
  611.             want_variable();
  612.         return;
  613.         }
  614.     if ((ns = new_symbol(ctoke, type, 
  615.         (rframe == global_frame ? GLOBAL : LOCAL), rframe)) == NULL)
  616.         return;
  617.     if (!next_token())
  618.         return;
  619.     ns->doff = rframe->dcount;    /* reserve space */
  620.     if (cttype == '[')    /* it's an array, yay! */
  621.         {
  622.         get_iexpress();
  623.         op = rframe->code_buf + rframe->op_count - 1;
  624.         if (op->type != OP_CON)
  625.             {
  626.             say_fatal("Array dimension must be constant");
  627.             return;
  628.             }
  629.         elements = op->data.i;
  630.         if (elements <= 0)
  631.             {
  632.             say_fatal("Array dimension must be positive");
  633.             return;
  634.             }
  635.         rframe->op_count -= 1;    /* clear constant from code stream */
  636.         ns->elements = elements;
  637.         rframe->dcount += elements;    /* reserve space */
  638.         if (!need_token())
  639.             return;
  640.         if (cttype != ']')
  641.             {
  642.             expecting_got("]", ctoke);
  643.             return;
  644.             }
  645.         }
  646.     else
  647.         {
  648.         rframe->dcount += 1;    /* reserve space */
  649.         pushback_token();
  650.         }
  651.     if (!next_token())
  652.         return;
  653.     if (cttype != ',')
  654.         {
  655.         pushback_token();
  656.         return;
  657.         }
  658.     }
  659. }
  660.  
  661.